12 research outputs found
Are Formal Contracts a useful Digital Twin of Software Systems?
Digital Twins are a trend topic in the industry today to either manage runtime information or forecast properties of devices and products. The techniques for Digitial Twins are already employed in several disciplines of formal methods, in particular, formal verification, runtime verification and specification inference. In this paper, we connect the Digital Twin concept and existing research areas in the field of formal methods. We sketch how digital twins for software-centric systems can be forged from existing formal methods
Smart Contracts: Application Scenarios for Deductive Program Verification
Smart contracts are programs that run on a distributed ledger platform. They usually manage resources representing valuable assets. Moreover, their source code is visible to potential attackers, they are distributed, and bugs are hard to fix. Thus, they are susceptible to attacks exploiting programming errors. Their vulnerability makes a rigorous formal analysis of the functional correctness of smart contracts highly desirable.
In this short paper, we show that the architecture of smart contract platforms offers a computation model for smart contracts that yields itself naturally to deductive program verification. We discuss different classes of correctness properties of distributed ledger applications, and show that design-by-contract verification tools are suitable to prove these properties. We present experiments where we apply the KeY verification tool to smart contracts in the Hyperledger Fabric framework which are implemented in Java and specified using the Java Modeling Language
Formal Specification and Verification of Hyperledger Fabric Chaincode
Smart contracts are programs building on blockchain technology.
They implement functionality that has been agreed on between
the concerned parties on a network. However, their immutability
and exposed position make them vulnerable to programming errors,
leading to faulty behavior and possible exploits. Therefore,
smart contracts demand a particularly thorough analysis,
ideally using formal program verification. In this paper, we
present an approach for the deductive verification of
Hyperledger Fabric smart contracts using the KeY prover.
We have extended KeY to handle Fabric ledger implementations;
in particular, we have developed mechanisms for reasoning about
serialization and object persistence. The feasibility of our
approach is demonstrated with a small case study
Continuous Secure Software Development and Analysis
Software security becomes increasingly important nowadays. Security should be considered as early as
possible in the software development. However, considering different aspects of security is a complex
task. In this paper, we propose an extendable framework for continuous secure software development
and evolution. The framework provides interconnected analyses on different stages of development.
Explicit assumption management helps to verify the security requirements more properly. Thus, the
security of the system under development can be estimated more accurately. Finally, the concrete assumptions also help to identify and close security gaps that arise during the softwareâs lifetime
Combining rule- and SMT-based reasoning for verifying floating-point Java programs in KeY
Deductive verification has been successful in verifying interesting properties of real-world programs. One notable gap is the limited support for floating-point reasoning. This is unfortunate, as floating-point arithmetic is particularly unintuitive to reason about due to rounding as well as the presence of the special values infinity and âNot a Numberâ (NaN). In this article, we present the first floating-point support in a deductive verification tool for the Java programming language. Our support in the KeY verifier handles floating-point arithmetics, transcendental functions, and potentially rounding-type casts. We achieve this with a combination of delegation to external SMT solvers on the one hand, and KeY-internal, rule-based reasoning on the other hand, exploiting the complementary strengths of both worlds. We evaluate this integration on new benchmarks and show that this approach is powerful enough to prove the absence of floating-point special valuesâoften a prerequisite for correct programsâas well as functional properties, for realistic benchmarks
Model-driven Quantification of Correctness with Palladio and KeY
In this report, we present an approach for the quantification of correctness of service-oriented software systems by combining the modeling tool Palladio and the deductive verification approach KeY.
Our approach uses Palladio for modeling the service-oriented architecture, the usage scenarios of the system (called services) in particular, and the distribution of values for the parameters provided by the users. The correctness of a service is modeled as a Boolean condition. We use Palladio to compute the probability of a service being called with critical parameters, i.e., in a way that its correctness condition is violated. The critical parameters are computed by KeY, a deductive verification tool for Java. The approach is not limited to KeY: Other techniques, such as bug finding (testing, bounded model checking) can be used, as well as other
verification tools.
We present two scenarios, which we use as examples to evaluate the feasibility of the approach. Finally, we close with remarks on the extension to security properties.
Furthermore, we discuss a possible approach to guide developers to locations of the code that should be verified or secured
Combining rule- and SMT-based reasoning for verifying floating-point Java programs in KeY
Deductive verification has been successful in verifying interesting properties of real-world programs. One notable gap is the limited support for floating-point reasoning. This is unfortunate, as floating-point arithmetic is particularly unintuitive to reason about due to rounding as well as the presence of the special values infinity and âNot a Numberâ (NaN). In this article, we present the first floating-point support in a deductive verification tool for the Java programming language. Our support in the KeY verifier handles floating-point arithmetics, transcendental functions, and potentially rounding-type casts. We achieve this with a combination of delegation to external SMT solvers on the one hand, and KeY-internal, rule-based reasoning on the other hand, exploiting the complementary strengths of both worlds. We evaluate this integration on new benchmarks and show that this approach is powerful enough to prove the absence of floating-point special valuesâoften a prerequisite for correct programsâas well as functional properties, for realistic benchmarks
Deductive Verification of Floating-Point Java Programs in KeY
Deductive verification has been successful in verifying interesting
properties of real-world programs. One notable gap is the limited support for
floating-point reasoning. This is unfortunate, as floating-point arithmetic is
particularly unintuitive to reason about due to rounding as well as the
presence of the special values infinity and `Not a Number' (NaN). In this
paper, we present the first floating-point support in a deductive verification
tool for the Java programming language. Our support in the KeY verifier handles
arithmetic via floating-point decision procedures inside SMT solvers and
transcendental functions via axiomatization. We evaluate this integration on
new benchmarks, and show that this approach is powerful enough to prove the
absence of floating-point special values -- often a prerequisite for further
reasoning about numerical computations -- as well as certain functional
properties for realistic benchmarks
Modeling and Enforcing Access Control Policies for Smart Contracts
Töberg J-P, Schiffl J, Reiche F, Beckert B, Heinrich R, Reussner R. Modeling and Enforcing Access Control Policies for Smart Contracts. In: 2022 IEEE International Conference on Decentralized Applications and Infrastructures (DAPPS). IEEE; 2022: 38-47.Ethereum smart contracts expose their functions to an untrusted network. Therefore, access control is of utmost importance. Nevertheless, many smart contracts have suffered exploits due to improper design or implementation of access control policies. In this work, we propose an approach for modeling role-based access control policies for Ethereum smart contracts on the architecture level, and we describe a process for ensuring that the implementation is correct w.r.t. that model. We achieve this through a combination of code generation, formal verification and static code analysis. Additionally, we provide an argument for the correctness of our approach and demonstrate its feasibility by detecting manually introduced violations in a case study